/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.thinkinbunny.codec.binary;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

import org.thinkinbunny.codec.binary.BaseNCodec.Context;

/**
 * Abstract superclass for Base-N input streams.
 * 
 * @since 1.5
 * @version $Id: BaseNCodecInputStream.java 1378740 2012-08-29 21:18:47Z tn $
 */
public class BaseNCodecInputStream extends FilterInputStream {

	private final BaseNCodec baseNCodec;

	private final boolean doEncode;

	private final byte[] singleByte = new byte[1];

	private final Context context = new Context();

	protected BaseNCodecInputStream(InputStream in, BaseNCodec baseNCodec,
			boolean doEncode) {
		super(in);
		this.doEncode = doEncode;
		this.baseNCodec = baseNCodec;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @return <code>0</code> if the {@link InputStream} has reached
	 *         <code>EOF</code>, <code>1</code> otherwise
	 * @since 1.7
	 */
	@Override
	public int available() throws IOException {
		// Note: the logic is similar to the InflaterInputStream:
		// as long as we have not reached EOF, indicate that there is more
		// data available. As we do not know for sure how much data is left,
		// just return 1 as a safe guess.

		return context.eof ? 0 : 1;
	}

	/**
	 * Marks the current position in this input stream.
	 * <p>
	 * The {@link #mark} method of {@link BaseNCodecInputStream} does nothing.
	 * </p>
	 * 
	 * @param readLimit
	 *            the maximum limit of bytes that can be read before the mark
	 *            position becomes invalid.
	 * @since 1.7
	 */
	@Override
	public synchronized void mark(int readLimit) {
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @return always returns <code>false</code>
	 */
	@Override
	public boolean markSupported() {
		return false; // not an easy job to support marks
	}

	/**
	 * Reads one <code>byte</code> from this input stream.
	 * 
	 * @return the byte as an integer in the range 0 to 255. Returns -1 if EOF
	 *         has been reached.
	 * @throws IOException
	 *             if an I/O error occurs.
	 */
	@Override
	public int read() throws IOException {
		int r = read(singleByte, 0, 1);
		while (r == 0) {
			r = read(singleByte, 0, 1);
		}
		if (r > 0) {
			final byte b = singleByte[0];
			return b < 0 ? 256 + b : b;
		}
		return BaseNCodec.EOF;
	}

	/**
	 * Attempts to read <code>len</code> bytes into the specified <code>b</code>
	 * array starting at <code>offset</code> from this InputStream.
	 * 
	 * @param b
	 *            destination byte array
	 * @param offset
	 *            where to start writing the bytes
	 * @param len
	 *            maximum number of bytes to read
	 * 
	 * @return number of bytes read
	 * @throws IOException
	 *             if an I/O error occurs.
	 * @throws NullPointerException
	 *             if the byte array parameter is null
	 * @throws IndexOutOfBoundsException
	 *             if offset, len or buffer size are invalid
	 */
	@Override
	public int read(byte b[], int offset, int len) throws IOException {
		if (b == null) {
			throw new NullPointerException();
		} else if (offset < 0 || len < 0) {
			throw new IndexOutOfBoundsException();
		} else if (offset > b.length || offset + len > b.length) {
			throw new IndexOutOfBoundsException();
		} else if (len == 0) {
			return 0;
		} else {
			int readLen = 0;
			/*
			 * Rationale for while-loop on (readLen == 0): -----
			 * Base32.readResults() usually returns > 0 or EOF (-1). In the rare
			 * case where it returns 0, we just keep trying.
			 * 
			 * This is essentially an undocumented contract for InputStream
			 * implementors that want their code to work properly with
			 * java.io.InputStreamReader, since the latter hates it when
			 * InputStream.read(byte[]) returns a zero. Unfortunately our
			 * readResults() call must return 0 if a large amount of the data
			 * being decoded was non-base32, so this while-loop enables proper
			 * interop with InputStreamReader for that scenario. ----- This is a
			 * fix for CODEC-101
			 */
			while (readLen == 0) {
				if (!baseNCodec.hasData(context)) {
					byte[] buf = new byte[doEncode ? 4096 : 8192];
					int c = in.read(buf);
					if (doEncode) {
						baseNCodec.encode(buf, 0, c, context);
					} else {
						baseNCodec.decode(buf, 0, c, context);
					}
				}
				readLen = baseNCodec.readResults(b, offset, len, context);
			}
			return readLen;
		}
	}

	/**
	 * Repositions this stream to the position at the time the mark method was
	 * last called on this input stream.
	 * <p>
	 * The {@link #reset} method of {@link BaseNCodecInputStream} does nothing
	 * except throw an {@link IOException}.
	 * 
	 * @throws IOException
	 *             if this method is invoked
	 * @since 1.7
	 */
	@Override
	public synchronized void reset() throws IOException {
		throw new IOException("mark/reset not supported");
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @throws IllegalArgumentException
	 *             if the provided skip length is negative
	 * @since 1.7
	 */
	@Override
	public long skip(long n) throws IOException {
		if (n < 0) {
			throw new IllegalArgumentException("Negative skip length: " + n);
		}

		// skip in chunks of 512 bytes
		final byte[] b = new byte[512];
		long todo = n;

		while (todo > 0) {
			int len = (int) Math.min(b.length, todo);
			len = this.read(b, 0, len);
			if (len == BaseNCodec.EOF) {
				break;
			}
			todo -= len;
		}

		return n - todo;
	}
}
